package com.sjf.day02.Array;

import java.io.*;

/**
 * 稀疏数组
 *
 * @author <huangtang>
 * @since 2021/12/16 9:10
 **/
public class SparseArray {

    public static void main(String[] args) {
        //创建一个原始二维数组11*11
        //0表示没有棋子，1表示黑子，2表示蓝子
        int[][] chessArr1 = new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][3]=2;
        //输出原始二维数组
        for (int[] ints : chessArr1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //将二维数组转成稀疏数组并输出
        toSparse(chessArr1);
        try {
            inData();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**w
     * 将稀疏数组转为普通二维数组
     * @param arr
     */
    public static void toNormal(int[][] arr){
        //先读取稀疏数组的第一行，创建出具体大小的数组
        int[][] chessArr2 = new int[arr[0][0]][arr[0][1]];

        for (int i = 1; i < arr.length; i++) {
            chessArr2[arr[i][0]][arr[i][1]] = arr[i][2];
        }
        System.out.println("=====恢复后的二维数组=====");
        for (int[] ints : chessArr2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }


    /**
     * 将二维数组转为稀疏数组并输出
     * @param arr
     */
    public static void toSparse(int[][] arr){
        //先遍历二维数组，得到非0的个数
        int sum = 0;
        for (int[] ints : arr) {
            for (int anInt : ints) {
                if(anInt!=0) sum++;
            }
        }
        //创建对应的稀疏数组
        int[][] sparseArr = new int[sum+1][3];
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=sum;
        //遍历二维数组，将非0的数放入稀疏数组中
        int count=0;//第几个非0数
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                if(arr[i][j]!=0){
                    count++;
                    sparseArr[count][0]=i;
                    sparseArr[count][1]=j;
                    sparseArr[count][2]=arr[i][j];
                }
            }
        }

        System.out.println("=====得到的稀疏数组为=====");
        for (int i = 0; i < sparseArr.length; i++) {
            System.out.println(sparseArr[i][0]+"\t"+sparseArr[i][1]+"\t"+sparseArr[i][2]);
        }
        //将稀疏数组转为二维数组
        toNormal(sparseArr);
        //将稀疏数组存到磁盘中
        try {
            toData(sparseArr);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    /**
     * 将稀疏数组输入到磁盘文件中
     * @param arr
     * @throws Exception
     */
    public static void toData(int[][] arr) throws Exception {
        FileOutputStream fos = new FileOutputStream(new File("D:\\map.data"));
        OutputStreamWriter osw = new OutputStreamWriter(fos);
        System.out.println("---写入中---");
        for (int i = 0; i < arr.length; i++) {
            osw.write(arr[i][0] + "\t" + arr[i][1] + "\t" + arr[i][2] + "\n");
        }
        osw.close();
        fos.close();
        System.out.println("---写入完成---");
    }

    /**
     * 将文件读入程序中
     * @throws Exception
     */
    public static void inData() throws Exception{
        FileInputStream fis = new FileInputStream(new File("D:\\map.data"));
        InputStreamReader isr = new InputStreamReader(fis);
        StringBuilder sb = new StringBuilder();
        System.out.println("读取中->>");
        while(isr.ready()){
            sb.append((char) isr.read());
        }
        System.out.println(sb);
        isr.close();
        fis.close();
    }

}
